package ig.ejb.metrica.da.session.transaction;

import ig.da.abs.AbsDA;
import ig.ejb.metrica.da.grupo.GrupoorigendatoDAO;
import ig.ejb.metrica.da.grupo.GrupoorigendatoDTO;
import ig.ejb.metrica.da.grupo.RelaciongrupoodatoDAO;
import ig.ejb.metrica.da.grupo.RelaciongrupoodatoDTO;
import ig.ejb.metrica.da.session.AccionesFlujosSBLocal;
import ig.ejb.metrica.da.session.AccionesFlujosSBLocalHome;
import ig.ejb.metrica.da.session.AccionesPosicionesFlujosSBLocal;
import ig.ejb.metrica.da.session.AccionesPosicionesFlujosSBLocalHome;
import ig.ejb.metrica.da.session.AccionesPosicionesSBLocal;
import ig.ejb.metrica.da.session.AccionesPosicionesSBLocalHome;
import ig.ejb.metrica.da.session.AccionesSBLocal;
import ig.ejb.metrica.da.session.AccionesSBLocalHome;
import ig.ejb.metrica.da.session.AccionesValoresSBLocal;
import ig.ejb.metrica.da.session.AccionesValoresSBLocalHome;
import ig.ejb.metrica.da.session.AdicionalesContratosLocal;
import ig.ejb.metrica.da.session.AdicionalesContratosLocalHome;
import ig.ejb.metrica.da.session.ContratosSimplesFlujosSBLocal;
import ig.ejb.metrica.da.session.ContratosSimplesFlujosSBLocalHome;
import ig.ejb.metrica.da.session.ContratosSimplesSBLocal;
import ig.ejb.metrica.da.session.ContratosSimplesSBLocalHome;
import ig.ejb.metrica.da.session.ContratosSimplesTasaPagoSBLocal;
import ig.ejb.metrica.da.session.ContratosSimplesTasaPagoSBLocalHome;
import ig.ejb.metrica.da.session.EmisoresSBLocal;
import ig.ejb.metrica.da.session.EmisoresSBLocalHome;
import ig.ejb.metrica.da.session.EmpresasUnidadesNegociosSBLocal;
import ig.ejb.metrica.da.session.EmpresasUnidadesNegociosSBLocalHome;
import ig.ejb.metrica.da.session.EspeciesFlujosLocal;
import ig.ejb.metrica.da.session.EspeciesFlujosLocalHome;
import ig.ejb.metrica.da.session.EspeciesPosicionesFlujosLocal;
import ig.ejb.metrica.da.session.EspeciesPosicionesFlujosLocalHome;
import ig.ejb.metrica.da.session.EspeciesPosicionesSBLocal;
import ig.ejb.metrica.da.session.EspeciesPosicionesSBLocalHome;
import ig.ejb.metrica.da.session.EspeciesSBLocal;
import ig.ejb.metrica.da.session.EspeciesSBLocalHome;
import ig.ejb.metrica.da.session.EspeciesTasasPagoLocal;
import ig.ejb.metrica.da.session.EspeciesTasasPagoLocalHome;
import ig.ejb.metrica.da.session.EspeciesValoresSBLocal;
import ig.ejb.metrica.da.session.EspeciesValoresSBLocalHome;
import ig.ejb.metrica.da.session.LibrosCuentasProductosSBLocal;
import ig.ejb.metrica.da.session.LibrosCuentasProductosSBLocalHome;
import ig.ejb.metrica.da.session.RelacionEspeciesSubcuentasSBLocal;
import ig.ejb.metrica.da.session.RelacionEspeciesSubcuentasSBLocalHome;
import ig.ejb.metrica.da.session.RelacionMonedasSubCuentasSBLocal;
import ig.ejb.metrica.da.session.RelacionMonedasSubCuentasSBLocalHome;
import ig.ejb.metrica.da.session.RelacionsubcuentasproductosSBLocal;
import ig.ejb.metrica.da.session.RelacionsubcuentasproductosSBLocalHome;
import ig.ejb.metrica.da.session.TasaaSBLocal;
import ig.ejb.metrica.da.session.TasaaSBLocalHome;
import ig.ejb.metrica.da.session.TasasValoresSBLocal;
import ig.ejb.metrica.da.session.TasasValoresSBLocalHome;
import ig.ejb.metrica.da.session.ValoresMonedasSBLocal;
import ig.ejb.metrica.da.session.ValoresMonedasSBLocalHome;
import ig.ejb.metrica.da.util.AccionesDTO;
import ig.ejb.metrica.da.util.AccionesflujosDTO;
import ig.ejb.metrica.da.util.AccionesposicionesDTO;
import ig.ejb.metrica.da.util.AccionesposicionesflujosDTO;
import ig.ejb.metrica.da.util.AccionesvaloresDTO;
import ig.ejb.metrica.da.util.AdicionalescontratosDTO;
import ig.ejb.metrica.da.util.ContratossimplesDTO;
import ig.ejb.metrica.da.util.ContratossimplesflujosDTO;
import ig.ejb.metrica.da.util.ContratossimplestasaspagoDTO;
import ig.ejb.metrica.da.util.EmisoresDTO;
import ig.ejb.metrica.da.util.EmpresasUnidadesnegociosDTO;
import ig.ejb.metrica.da.util.EspeciesDTO;
import ig.ejb.metrica.da.util.EspeciesflujosDTO;
import ig.ejb.metrica.da.util.EspeciesposicionesDTO;
import ig.ejb.metrica.da.util.EspeciesposicionesflujosDTO;
import ig.ejb.metrica.da.util.EspeciestasaspagoDTO;
import ig.ejb.metrica.da.util.EspeciesvaloresDTO;
import ig.ejb.metrica.da.util.IComun;
import ig.ejb.metrica.da.util.LibrosCuentasProductosDTO;
import ig.ejb.metrica.da.util.RelacionespeciessubcuentasDTO;
import ig.ejb.metrica.da.util.RelacionmonedassubcuentasDTO;
import ig.ejb.metrica.da.util.RelacionsubcuentasproductosDTO;
import ig.ejb.metrica.da.util.TasasDTO;
import ig.ejb.metrica.da.util.TasasvaloresDTO;
import ig.ejb.metrica.da.util.ValoresmonedasDTO;
import ig.metrica.ejb.bean.Origenesdatos;
import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.*;
import javax.ejb.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

/**
 * This is the bean class for the AgrupacionSBBean enterprise bean.
 * Created 3/08/2006 11:21:47 AM
 * @author jsanchez
 */
public class AgrupacionSBBean implements SessionBean, AgrupacionSBRemoteBusiness, AgrupacionSBLocalBusiness {

    private SessionContext context;
    private Hashtable HTablasProcesadas = new Hashtable();
    private DataSource ds = null;
    private boolean delete = true;
    // <editor-fold defaultstate="collapsed" desc="EJB infrastructure methods. Click the + sign on the left to edit the code.">
    // TODO Add code to acquire and use other enterprise resources (DataSource, JMS, enterprise bean, Web services)
    // TODO Add business methods or web service operations
    /**
     * @see javax.ejb.SessionBean#setSessionContext(javax.ejb.SessionContext)
     */
    public void setSessionContext(SessionContext aContext) {
        context = aContext;
    }

    /**
     * @see javax.ejb.SessionBean#ejbActivate()
     */
    public void ejbActivate() {

    }

    /**
     * @see javax.ejb.SessionBean#ejbPassivate()
     */
    public void ejbPassivate() {

    }

    /**
     * @see javax.ejb.SessionBean#ejbRemove()
     */
    public void ejbRemove() {

    }
    // </editor-fold>
    /**
     * See section 7.10.3 of the EJB 2.0 specification
     * See section 7.11.3 of the EJB 2.1 specification
     */
    public void ejbCreate() {
    // TODO implement ejbCreate if necessary, acquire resources
    // This method has access to the JNDI context so resource aquisition
    // spanning all methods can be performed here such as home interfaces
    // and data sources.
    }

    public void procesarOpcion(Object... obj) throws java.lang.Exception {
        Collection consulta = null;
        Origenesdatos element = null;
        //TODO implement procesarOpcion
        //0 El primer elemento siempre es la operacion Example ELIMINAR o AGRUPAR
        //1 El Segundo elemento siempre es la ENTIDAD del origen de datos
        //2 El Tercer elemto siempre es el la fecha Final o fecha de corte
        //3 El consecutuvo
        //4 Si los datos actuales deben ser eliminado (true|false)
        try {


            int contador = 0;
            if (obj[0].equals(IComun.AGRUPAR)) {
                java.sql.Date mFecha = new java.sql.Date(((Date) obj[2]).getTime());
//                java.sql.Date mFecha2 = null;//java.sql.Date.valueOf(getFecha((Date) obj[2], (Date) obj[3]));
                Origenesdatos origenesdatos = new Origenesdatos();
                Collection OrigenDatosAll = origenesdatos.getOrigenesDatosAgrupados();
                Iterator misOrigenes = OrigenDatosAll.iterator();
                Integer CONSECUTIVO = (Integer) obj[3];
                while (misOrigenes.hasNext()) {
                    contador++;
                    element = (Origenesdatos) misOrigenes.next();
                    if (!element.getQUERY().trim().isEmpty() && !element.getQUERY().trim().equalsIgnoreCase("*") && /*element.getENTIDAD().trim().equals(obj[1]) &&*/ CONSECUTIVO.equals(element.getCONSECUTIVO())) {
                        if (element.getQUERY().contains("${FECHA_INICIAL}")) {
                            throw new Exception("El proceso de Agrupacion de Datos, no maneja la propiedad ${FECHA_INICIAL}");
                        }
                        String QUERY = this.getQUERY(element.getQUERY(), false);
                        int ocurrencias = QUERY.replace("_FECHA_CORTE", "@").replace("_FECHA_INICIAL", "@").split("@").length;
                        if (ocurrencias > 1) {
                            consulta = origenesdatos.obtenerResultado2(element, mFecha.toString(), java.sql.Date.valueOf("2000-01-01").toString(), ocurrencias - 1);
                        } else {
                            consulta = origenesdatos.obtenerResultado(element, mFecha.toString());
                        }
                        if (consulta.toArray().length > 0) {
                            if (consulta.toArray().length == 1 && consulta.toArray()[0] instanceof AbsDA) {
                                ((AbsDA)consulta.toArray()[0]).procesar();
                            } else {
                                GrabarDatos(consulta, element.getID(), new Timestamp(((java.util.Date) obj[2]).getTime()));
                            }
                        }
                        return;
                    }
                }
            } else if (obj[0].equals(IComun.ELIMINAR)) {

            }
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
    }

    private void EliminarDatos(String tabla, Timestamp fecha) throws NamingException, SQLException {
        if( !delete )
            return;
        if (!HTablasProcesadas.containsKey(tabla.toUpperCase())) {
            HTablasProcesadas.put(tabla.toUpperCase(), tabla.toUpperCase());
            Connection c = null;
            PreparedStatement pre = null;
            try {
                if (ds == null) {
                    Context ctx = new InitialContext();
                    ds = (DataSource) ctx.lookup("java:/METRICADA");
                }
                c = ds.getConnection();
                pre = c.prepareStatement("DELETE FROM " + tabla.toUpperCase() + " WHERE FECHA_CORTE = ?");
                pre.setTimestamp(1, fecha);
                pre.executeUpdate();
            } catch (Exception e) {
            } finally {
                try {
                    c.close();
                } catch (Exception e) {
                }
                try {
                    pre.close();
                } catch (Exception e) {
                }
            }
            try {
                if (ds == null) {
                    Context ctx = new InitialContext();
                    ds = (DataSource) ctx.lookup("java:/METRICADA");
                }
                c = ds.getConnection();
                pre = c.prepareStatement("DELETE FROM " + tabla.toUpperCase() + " WHERE FECHA_CORTE = ?");
                pre.setDate(1, new java.sql.Date(fecha.getTime()));
                pre.executeUpdate();
            } catch (Exception e) {
            } finally {
                try {
                    c.close();
                } catch (Exception e) {
                }
                try {
                    pre.close();
                } catch (Exception e) {
                }
            }
        }
    }

    private void GrabarDatos(Collection Datos, Integer mId, Timestamp fechaCorte) throws Exception {
        fechaCorte.setHours(0);
        fechaCorte.setMinutes(0);
        fechaCorte.setSeconds(0);
        fechaCorte.setMinutes(0);
        Double saldoActual = null;
        Timestamp fechaInicial = null;
        Double saldoMora = null;
        Integer alturaMora = null;
        Double posicionPasiva = null;
        Double posicionActiva = null;
        Integer unidadCaptura = null;
        Integer subCuenta = null;
        Double saldoContable = null;
        Double tirCompra = null;
        Double tirValoracion = null;
        Double valorFecha1 = null;
        Double valorFecha2 = null;
        Double valorTirFecha1 = null;
        Double valorTirFecha2 = null;
        Integer liquidacion = null;
        Integer nominalModalidaPago = null;
        String modalidadPago = null;
        Integer nominalModalidaSpread = null;
        String modalidadSpread = null;
        Timestamp fechaFin = null;
        Timestamp fechaInicio = null;
        Double spread = null;
        Integer forma = null;
        String producto = null;
        Integer diasXanio = null;
        Integer diasXmes = null;
        String nemotecnico = null;
        Integer activo = null;
        Iterator Registro = Datos.iterator();
        Integer id = null, id1 = null, id2 = null, id3 = null, id4 = null;
        String nom = null, nom1 = null, nom2 = null, nom3 = null;
        Integer nominal = null;
        String tipo = null, modalidad = null;
        Double valor = null;
        Double interes1 = null, interes2 = null;
        Timestamp fecha = null;
        Integer posicion = null;
        Integer bursatil = null;
        String nit = null;
//        String tfecha = null;
        String unidad = null;
        Integer conocido = null;
        String isin = null;
        System.out.print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        System.out.println("Grabando " + Datos.size() + " Registros para el origen de datos :" + mId);
        try {
            switch (mId) {
                case 1001:
                    while (Registro.hasNext()) {
//                     NOMBREMONEDA                              FECHA                   VALOR        IDMONEDA
//                     ----------------------------------------  ----------------------  -----------  -----------
//                     PESOS                                     9/08/2006 11:34:49 AM   0            0
//                     DOLAR                                     11/04/1996 12:00:00 AM  1046.55      1
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        fecha = this.getFecha(Reg[1].toString());
                        valor = Double.parseDouble(Reg[2].toString());
                        id = Integer.parseInt(Reg[3].toString());
                        this.EliminarDatos("Valoresmonedas", fechaCorte);
                        GrabarDatos(new ValoresmonedasDTO(id, fechaCorte, nom, fecha, valor));
                    }
                    break;
                case 1002:
//                ((TasaaSBLocalHome)this.lookupSBBean("TasaaSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//                    NOMBRE      TIPO     MODALIDAD     NOMINALMODALIDAD     IDTASA
//                     ----------  -------  ------------  -------------------  ---------
//                     FS          SIMPLE   AV            0                    1
//                     BTPE        CURVA    AV            0                    2
//                     BTUV        CURVA    AV            0                    3
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        tipo = Reg[1].toString();
                        modalidad = Reg[2].toString();
                        nominal = Integer.parseInt(Reg[3].toString());
                        id = Integer.parseInt(Reg[4].toString());
                        this.EliminarDatos("Tasas", fechaCorte);
                        GrabarDatos(new TasasDTO(id, fechaCorte, nom, tipo, modalidad, nominal));
                    }
                    break;
                case 1003:
//                ((TasasValoresSBLocalHome)this.lookupSBBean("TasasValoresSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//                     NOMBRETASA     FECHA                   POSICION     VALOR       IDTASA
//                     -------------  ----------------------  -----------  ----------  ---------
//                     BTPE           11/02/2006 12:00:00 AM  1            7.187424    2
//                     BTPE           13/02/2006 12:00:00 AM  1            8.018364    2
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        fecha = this.getFecha(Reg[1].toString());
                        posicion = Integer.parseInt(Reg[2].toString());
                        valor = Double.parseDouble(Reg[3].toString());
                        id = Integer.parseInt(Reg[4].toString());
                        this.EliminarDatos("Tasasvalores", fechaCorte);
                        GrabarDatos(new TasasvaloresDTO(id, fechaCorte, nom, fecha, posicion, valor));
                    }
                    break;
                case 1004:
//                ((EmpresasUnidadesNegociosSBLocalHome)this.lookupSBBean("EmpresasUnidadesNegociosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//            NOMBREEMPRESA                                                 NOMBREUNIDAD                                        IDEMPRESA     IDUNIDAD
//             ------------------------------------------------------------  --------------------------------------------------  ------------  -----------
//             SEGUROS DE VIDA ALFA S.A                                      ARP                                                 2             1
//             SEGUROS ALFA S.A.                                             ALFA                                                1             2
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        nom1 = Reg[1].toString();
                        id = Integer.parseInt(Reg[2].toString());
                        id1 = Integer.parseInt(Reg[3].toString());
                        this.EliminarDatos("EmpresasUnidadesnegocios", fechaCorte);
                        GrabarDatos(new EmpresasUnidadesnegociosDTO(id, fechaCorte, nom, nom1, id1));
                    }
                    break;
                case 1005:
//                ((LibrosCuentasProductosSBLocalHome)this.lookupSBBean("LibrosCuentasProductosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// NOMBRELIBRO     NOMBRECUENTA     NOMBREPRODUCTO           ACTIVO     NOMBREMONEDA      IDLIBRO     IDCUENTA     IDPRODUCTO     IDMONEDA
// --------------  ---------------  -----------------------  ---------  ----------------  ----------  -----------  -------------  -----------
// TESORERIA       INVERSIONES      ACCIONES-PESOS           1          PESOS             1           1            4000           0
// TESORERIA       INVERSIONES      COMERCIALES-DOLAR        1          DOLAR             1           1            1001           1
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        nom1 = Reg[1].toString();
                        nom2 = Reg[2].toString();
                        activo = Integer.parseInt(Reg[3].toString());
                        nom3 = Reg[4].toString();
                        id = Integer.parseInt(Reg[5].toString());
                        id1 = Integer.parseInt(Reg[6].toString());
                        id2 = Integer.parseInt(Reg[7].toString());
                        id3 = Integer.parseInt(Reg[8].toString());
                        this.EliminarDatos("LibrosCuentasProductos", fechaCorte);
                        GrabarDatos(new LibrosCuentasProductosDTO(id, fechaCorte, nom, nom1, nom2, activo, id1, id2, id3, nom3));
                    }
                    break;
                case 1006:
//                ((EmisoresSBLocalHome)this.lookupSBBean("EmisoresSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//                NOMBREEMISOR                                                  NIT             IDEMISOR
//                -----------------------------------------------------------   --------------  ----------
//                GOBIERNO NACIONAL                                           	8999990830	1
//                BANCO DE LA REPUBLICA                                       	8600052167	2
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        nit = Reg[1].toString();
                        id = Integer.parseInt(Reg[2].toString());
                        this.EliminarDatos("Emisores", fechaCorte);
                        GrabarDatos(new EmisoresDTO(id, fechaCorte, nom, nit));
                    }
                    break;
                case 1007:
//                ((AccionesSBLocalHome)this.lookupSBBean("AccionesSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//                    NOMBREACCION        BURSATIL        NombreMoneda        NombreEmisor
//                    ------------------  --------------  -----------------   -----------------
//                    la accion           1               DOLAR               MI EMPRESA
                        Object[] Reg = (Object[]) Registro.next();

                        nom = Reg[0].toString();
                        bursatil = Integer.parseInt(Reg[1].toString().trim());
                        nom1 = Reg[2].toString().trim();
                        nom2 = Reg[3].toString().trim();
                        this.EliminarDatos("Acciones", fechaCorte);
                        GrabarDatos(new AccionesDTO(fechaCorte, nom, bursatil, nom1, nom2));
                    }
                    break;
                case 1008:
//                ((AccionesPosicionesSBLocalHome)this.lookupSBBean("AccionesPosicionesBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//                    IDPOSICION      UNIDADES        BURSATIL        ACCION      PRODUCTO        UNIDADNEGOCIO
//                    -------------   --------------  --------------  ----------  --------------  --------------
//                    1                 1               1               1           1               1
                        Object[] Reg = (Object[]) Registro.next();
                        this.EliminarDatos("Accionesposiciones", fechaCorte);
                        GrabarDatos(new AccionesposicionesDTO(
                                Integer.valueOf(Reg[0].toString()),
                                fechaCorte,
                                Double.valueOf(Reg[2].toString()),
                                Integer.valueOf(Reg[3].toString()),
                                Reg[4].toString(),
                                Reg[5].toString(),
                                Reg[6].toString()));
                    }
                    break;
                case 1009:
//                ((AccionesValoresSBLocalHome)this.lookupSBBean("AccionesValoresSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//                    NOMBREACCION      FECHA       VALOR
//                    ----------------  ----------  ---------
//                    MI ACCION         01/01/2005  6000
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        fecha = this.getFecha(Reg[1].toString());
                        valor = Double.parseDouble(Reg[2].toString());
                        this.EliminarDatos("Accionesvalores", fechaCorte);
                        GrabarDatos(new AccionesvaloresDTO(fechaCorte, nom, fecha, valor));
                    }
                    break;
                case 1010:
//                ((AccionesFlujosSBLocalHome)this.lookupSBBean("AccionesFlujosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
                        Object[] Reg = (Object[]) Registro.next();
//     IDACCION    NOMBRE_ACCION    FECHA      CAPITAL    INTERES_FIJO     INTERES_VARIABLE      CONOCIDO
//     ----------  ---------------  -------    ---------  ---------------  ------------------    -------------
//     1           MI OTRA AA       01/01/2006  333       3333               3333                1
                        id = Integer.parseInt(Reg[0].toString());
                        nom = Reg[1].toString();
                        fecha = this.getFecha(Reg[2].toString());
                        valor = Double.parseDouble(Reg[3].toString());
                        interes1 = Double.parseDouble(Reg[4].toString());
                        interes2 = Double.parseDouble(Reg[5].toString());
                        conocido = Integer.parseInt(Reg[6].toString());
                        this.EliminarDatos("Accionesflujos", fechaCorte);
                        GrabarDatos(new AccionesflujosDTO(id, fechaCorte, nom, fecha, valor, interes1, interes2, conocido));
                    }
                    break;
                case 1011:
//                ((AccionesFlujosSBLocalHome)this.lookupSBBean("AccionesPosicionesFlujosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//   IDPOSICION        FECHA                 CAPITAL               INTERES_FIJO          INTERES_VARIABLE      CONOCIDO
//  -------------      --------------------  ---------------       ---------------       ------------------    --------
//  1                  01/01/2006             3333                   33333333              33333333333           1
                        Object[] Reg = (Object[]) Registro.next();
                        id = Integer.parseInt(Reg[0].toString());
                        fecha = this.getFecha(Reg[1].toString());
                        valor = Double.parseDouble(Reg[2].toString());
                        interes1 = Double.parseDouble(Reg[3].toString());
                        interes2 = Double.parseDouble(Reg[4].toString());
                        conocido = Integer.parseInt(Reg[5].toString());
                        this.EliminarDatos("Accionesposicionesflujos", fechaCorte);
                        GrabarDatos(new AccionesposicionesflujosDTO(id, fechaCorte, fecha, valor, interes1, interes2, conocido));
                    }
                    break;
                case 1012:
//                ((EspeciesSBLocalHome)this.lookupSBBean("EspeciesSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// ISIN      NOMBREESPECIE                     NOMBREMONEDA      NOMBREEMISOR              VALOREMISION     DIASXANO     DIASXMES     IDESPECIE     IDMONEDA     IDEMISOR     NEMOTECNICO
// --------  --------------------------------- ----------------- ------------------------- ---------------  -----------  -----------  ------------  -----------  -----------  ---------------
// ISIN2     B. YANKEE EN EUROS ENE-08         EURO              GOBIERNO NACIONAL         0                1            1            2             4            1            XS0123152521
// ISIN3     TES CUPON CORTO PLAZO MAR-06      PESOS             MINISTERIO DE HACIENDA    0                1            1            3             0            86           TBFC04140306
                        Object[] Reg = (Object[]) Registro.next();
                        isin = Reg[0].toString();
                        nom = Reg[1].toString();
                        nom1 = Reg[2].toString();
                        nom2 = Reg[3].toString();
                        valor = Double.parseDouble(Reg[4].toString());
                        diasXanio = Integer.parseInt(Reg[5].toString());
                        diasXmes = Integer.parseInt(Reg[6].toString());
                        id = Integer.parseInt(Reg[7].toString());
                        id1 = Integer.parseInt(Reg[8].toString());
                        id2 = Integer.parseInt(Reg[9].toString());
                        if (Reg[10] != null) {
                            nemotecnico = Reg[10].toString();
                        }
                        this.EliminarDatos("Especies", fechaCorte);
                        GrabarDatos(new EspeciesDTO(id, fechaCorte, isin, nom, nom1, nom2, valor, diasXanio, diasXmes, id1, id2, nemotecnico));
                    }
                    break;
                case 1013:
//                ((EspeciesPosicionesSBLocalHome)this.lookupSBBean("EspeciesPosicionesSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// IDPOSICION     VALORNOMINAL     TIPO             ISINESPECIE     PRODUCTO              UNIDADNEGOCIO
// -------------  ---------------  ---------------  --------------  --------------------- -----------------------
// 100100143      240800000        NEGOCIABLE       ISIN53          COMERCIALES-PESOS     ARP
// 100100144      249000000        NEGOCIABLE       ISIN54          COMERCIALES-PESOS     ARP
                        Object[] Reg = (Object[]) Registro.next();
                        id = Integer.parseInt(Reg[0].toString());
                        valor = Double.parseDouble(Reg[1].toString());
                        tipo = Reg[2].toString();
                        isin = Reg[3].toString();
                        producto = Reg[4].toString();
                        unidad = Reg[5].toString();
                        fechaInicial = this.getFecha(Reg[7].toString());
                        saldoMora = Double.parseDouble(Reg[8].toString());
                        alturaMora = Integer.parseInt(Reg[9].toString());
                        saldoActual = Double.parseDouble(Reg[10].toString());
                        this.EliminarDatos("Especiesposiciones", fechaCorte);
                        GrabarDatos(new EspeciesposicionesDTO(id, fechaCorte, valor, tipo, isin, producto, unidad, fechaInicial, saldoMora, alturaMora, saldoActual));
                    }
                    break;
                case 1014:
//                ((EspeciesValoresSBLocalHome)this.lookupSBBean("EspeciesValoresSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
//ISIN     FECHA     VALOR
// -------  --------  --------
                        Object[] Reg = (Object[]) Registro.next();
                        isin = Reg[0].toString();
                        fecha = this.getFecha(Reg[1].toString());
                        valor = Double.parseDouble(Reg[2].toString());
                        this.EliminarDatos("Especiesvalores", fechaCorte);
                        GrabarDatos(new EspeciesvaloresDTO(fechaCorte, isin, fecha, valor));
                    }
                    break;
                case 1015:
//                ((EspeciesFlujosLocalHome)this.lookupSBBean("EspeciesFlujosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// ISIN     FECHA     CAPITAL     INTERESFIJO     INTERESVARIABLE     CONOCIDO
// -------  --------  ----------  --------------  ------------------  -----------
                        Object[] Reg = (Object[]) Registro.next();
                        isin = Reg[0].toString();
                        fecha = this.getFecha(Reg[1].toString());
                        valor = Double.parseDouble(Reg[2].toString());
                        interes1 = Double.parseDouble(Reg[3].toString());
                        interes2 = Double.parseDouble(Reg[4].toString());
                        conocido = Integer.parseInt(Reg[5].toString());
                        this.EliminarDatos("Especiesflujos", fechaCorte);
                        GrabarDatos(new EspeciesflujosDTO(fechaCorte, isin, fecha, valor, interes1, interes2, conocido));
                    }
                    break;
                case 1016:
//                ((EspeciesTasasPagoLocalHome)this.lookupSBBean("EspeciesTasasPagoSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// ISIN     FORMA     SPREAD     FECHAINICIO             FECHAFIN                MODALIDADSPREAD     NOMINALMODALIDADSPREAD     MODALIDADPAGO     NOMINALMODALIDADPAGO     NOMBRETASA     LIQUIDAFINDEPERIODO
// -------  --------  ---------  ----------------------  ----------------------  ------------------  -------------------------  ----------------  -----------------------  -------------  ----------------------
// ISIN7    0         10         13/11/2001 12:00:00 AM  23/01/2012 12:00:00 AM  SV                  1                          SV                1                        FS             1
// ISIN47   3         7.1        27/09/2000 12:00:00 AM  27/09/2010 12:00:00 AM  AV                  1                          AV                1                        IPC            1

                        Object[] Reg = (Object[]) Registro.next();
                        isin = Reg[0].toString();
                        forma = Integer.parseInt(Reg[1].toString());
                        spread = Double.parseDouble(Reg[2].toString());
                        fechaInicio = this.getFecha(Reg[3].toString());
                        fechaFin = this.getFecha(Reg[4].toString());
                        modalidadSpread = Reg[5].toString();
                        nominalModalidaSpread = Integer.parseInt(Reg[6].toString());
                        modalidadPago = Reg[7].toString();
                        nominalModalidaPago = Integer.parseInt(Reg[8].toString());
                        nom = Reg[9].toString();
                        liquidacion = Integer.parseInt(Reg[10].toString());
                        this.EliminarDatos("Especiestasaspago", fechaCorte);
                        GrabarDatos(new EspeciestasaspagoDTO(fechaCorte, isin, forma, spread, fechaInicio, fechaFin, modalidadSpread, nominalModalidaSpread, modalidadPago, nominalModalidaPago, nom, liquidacion));
                    }
                    break;
                case 1017:
//                ((EspeciesPosicionesFlujosLocalHome)this.lookupSBBean("EspeciesPosicionesFlujosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// IDPOSICION     FECHA                   CAPITAL      INTERESFIJO     INTERESVARIABLE     CONOCIDO
// -------------  ----------------------  -----------  --------------  ------------------  -----------
// 100100143      29/09/2006 12:00:00 AM  0            0               30244480            0
// 100100143      29/09/2007 12:00:00 AM  0            0               30244480            0
                        Object[] Reg = (Object[]) Registro.next();
                        id = Integer.parseInt(Reg[0].toString());
                        fecha = this.getFecha(Reg[1].toString());
                        valor = Double.parseDouble(Reg[2].toString());
                        interes1 = Double.parseDouble(Reg[3].toString());
                        interes2 = Double.parseDouble(Reg[4].toString());
                        conocido = Integer.parseInt(Reg[5].toString());
                        this.EliminarDatos("Especiesposicionesflujos", fechaCorte);
                        GrabarDatos(new EspeciesposicionesflujosDTO(id, fechaCorte, fecha, valor, interes1, interes2, conocido));
                    }
                    break;
                case 1018:
//                ((ContratosSimplesSBLocalHome)this.lookupSBBean("ContratosSimplesSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// NOMBRE     TIPO     IDCONTRATO     PRODUCTO     UNIDADNEGOCIO     EMISOR     VALORNOMINAL
// ---------  -------  -------------  -----------  ----------------  ---------  ---------------
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        tipo = Reg[1].toString();
                        id = Double.valueOf(Reg[2].toString()).intValue();
                        producto = Reg[3].toString();
                        unidad = Reg[4].toString();
                        nom1 = Reg[5].toString();
                        valor = Double.parseDouble(Reg[6].toString());
                        fechaInicial = this.getFecha(Reg[7].toString());
                        saldoMora = Double.parseDouble(Reg[8].toString());
                        alturaMora = Integer.parseInt(Reg[9].toString());
                        saldoActual = Double.parseDouble(Reg[10].toString());
                        this.EliminarDatos("Contratossimples", fechaCorte);
//                    System.out.println("Tratando de insertar");
                        GrabarDatos(new ContratossimplesDTO(id, fechaCorte, nom, tipo, producto, unidad, nom1, valor, fechaInicial, saldoMora, alturaMora, saldoActual));
                    }
                    break;
                case 1019:
//                ((ContratosSimplesFlujosSBLocalHome)this.lookupSBBean("ContratosSimplesFlujosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// IDCONTRATO     FECHA     CAPITAL     INTERESFIJO     INTERESVARIABLE     CONOCIDO
// -------------  --------  ----------  --------------  ------------------  -----------
                        Object[] Reg = (Object[]) Registro.next();
                        id = Double.valueOf(Reg[0].toString()).intValue();
                        fecha = this.getFecha(Reg[1].toString());
                        valor = Double.parseDouble(Reg[2].toString());
                        interes1 = Double.parseDouble(Reg[3].toString());
                        interes2 = Double.parseDouble(Reg[4].toString());
                        conocido = Integer.parseInt(Reg[5].toString());
                        this.EliminarDatos("Contratossimplesflujos", fechaCorte);
                        GrabarDatos(new ContratossimplesflujosDTO(id, fechaCorte, fecha, valor, interes1, interes2, conocido));
                    }
                    break;
                case 1020:
//                ((ContratosSimplesTasaPagoSBLocalHome)this.lookupSBBean("ContratosSimplesTasaPagoSBBean")).create().removeByObject(fechaCorte);
// IDCONTRATO     FORMA     SPREAD     FECHAINICIO     FECHAFIN     MODALIDADSPREAD     NOMINALMODALIDADSPREAD     MODALIDADPAGO     NOMINALMODALIDADPAGO     IDTASAREFERENCIA     LIQUIDAFINDEPERIODO
// -------------  --------  ---------  --------------  -----------  ------------------  -------------------------  ----------------  -----------------------  -------------------  ----------------------
                    while (Registro.hasNext()) {
                        Object[] Reg = (Object[]) Registro.next();
                        id = Double.valueOf(Reg[0].toString()).intValue();
                        forma = Integer.parseInt(Reg[1].toString());
                        spread = Double.parseDouble(Reg[2].toString());
                        fechaInicio = this.getFecha(Reg[3].toString());
                        fechaFin = this.getFecha(Reg[4].toString());
                        modalidadSpread = Reg[5].toString();
                        nominalModalidaSpread = Integer.parseInt(Reg[6].toString());
                        modalidadPago = Reg[7].toString();
                        nominalModalidaPago = Integer.parseInt(Reg[8].toString());
                        id1 = Integer.parseInt(Reg[9].toString());
                        liquidacion = Integer.parseInt(Reg[10].toString());
                        this.EliminarDatos("Contratossimplestasaspago", fechaCorte);
                        GrabarDatos(new ContratossimplestasaspagoDTO(id, fechaCorte, forma, spread, fechaInicio, fechaFin, modalidadSpread, nominalModalidaSpread, modalidadPago, nominalModalidaPago, id, liquidacion));
//                    new ContratossimplestasaspagoDTO();
                    }
                    break;
                case 1021:
//                ((AdicionalesContratosLocalHome)this.lookupSBBean("AdicionalesContratosSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// IDCONTRATO     tircompra     tirvaloracion     valorFECHA1         valorFECHA2         valoraTirFecha1     valoraTirFecha2
// -------------  ------------  ----------------  ------------------  ------------------  ------------------  ------------------
// 100100143      0.0393        0.0877            274110305.94        275393925.9068      0                   319466629.3876
// 100100144      0.0272        0.065             273093159.22        274049960.3404      0                   292138850.402
                        Object[] Reg = (Object[]) Registro.next();
                        id = Integer.parseInt(Reg[0].toString());
                        tirCompra = Double.parseDouble(Reg[1].toString());
                        tirValoracion = Double.parseDouble(Reg[2].toString());
                        valorFecha1 = Double.parseDouble(Reg[3].toString());
                        valorFecha2 = Double.parseDouble(Reg[4].toString());
                        valorTirFecha1 = Double.parseDouble(Reg[5].toString());
                        valorTirFecha2 = Double.parseDouble(Reg[6].toString());
                        this.EliminarDatos("Adicionalescontratos", fechaCorte);
                        GrabarDatos(new AdicionalescontratosDTO(id, fechaCorte, tirCompra, tirValoracion, valorFecha1, valorFecha2, valorTirFecha1, valorTirFecha2));
                    }
                    break;
                case 1022:
//                ((RelacionEspeciesSubcuentasSBLocalHome)this.lookupSBBean("RelacionEspeciesSubcuentasSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// ISIN     TIPO              FORMATO     UNIDADCAPTURA     SUBCUENTA     SALDOCONTABLE
// -------  ----------------  ----------  ----------------  ------------  ----------------
// ISIN302  AL VENCIMIENTO    270         01                012           11771984.7481
// ISIN349  DISPONIBLE VENTA  269         01                051           6109263357.3632
                        Object[] Reg = (Object[]) Registro.next();
                        isin = Reg[0].toString();
                        tipo = Reg[1].toString();
                        forma = Integer.parseInt(Reg[2].toString());
                        unidadCaptura = Integer.parseInt(Reg[3].toString());
                        subCuenta = Integer.parseInt(Reg[4].toString());
                        saldoContable = Double.parseDouble(Reg[5].toString());
                        this.EliminarDatos("Relacionespeciessubcuentas", fechaCorte);
                        GrabarDatos(new RelacionespeciessubcuentasDTO(fechaCorte, isin, tipo, forma, unidadCaptura, subCuenta, saldoContable));
                    }
                    break;
                case 1023:
//                ((RelacionMonedasSubCuentasSBLocalHome)this.lookupSBBean("RelacionMonedasSubCuentasSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
// NOMBREMONEDA                              FORMATO     UNIDADCAPTURA     SUBCUENTA     POSICIONACTIVA     POSICIONPASIVA
// ----------------------------------------  ----------  ----------------  ------------  -----------------  -----------------
// DOLAR                                     271         1                 1             26751447.7209      0
// UVR                                       271         2                 2             29335267.2481      0
                        Object[] Reg = (Object[]) Registro.next();
                        nom = Reg[0].toString();
                        forma = Integer.parseInt(Reg[1].toString());
                        unidadCaptura = Integer.parseInt(Reg[2].toString());
                        subCuenta = Integer.parseInt(Reg[3].toString());
                        posicionActiva = Double.parseDouble(Reg[4].toString());
                        posicionPasiva = Double.parseDouble(Reg[5].toString());
                        this.EliminarDatos("Relacionmonedassubcuentas", fechaCorte);
                        GrabarDatos(new RelacionmonedassubcuentasDTO(fechaCorte, nom, forma, unidadCaptura, subCuenta, posicionActiva, posicionPasiva));
                    }
                    break;
//            case 1024:
//                //no implementar
//                //IDFORMATO,UNIDAD DE CAPTURA,SUBCUENTA,IDBALANCE
//                j=1;
//                while (Registro.hasNext()) {
//                    Object[] Reg = (Object[])Registro.next();
//                    Integer posicion0=Integer.parseInt(Reg[0].toString());
//                    Integer posicion1=Integer.parseInt(Reg[1].toString());
//                    Double  posicion2=Double.parseDouble(Reg[2].toString());
//                    Integer posicion3=Integer.parseInt(Reg[3].toString());
//                    GrabarDatos(new BalanceDTO(posicion0,posicion1,posicion2,posicion3));
//                    j++;
//                }
//                break;
//            case 1025:
//                //no implementar
//                //IDFORMATO,UNIDAD DE CAPTURA,SUBCUENTA,IDBALANCE
//                j=1;
//                while (Registro.hasNext()) {
//                    Object[] Reg = (Object[])Registro.next();
//                    Integer posicion0=Integer.parseInt(Reg[0].toString());
//                    String posicion1=Reg[1].toString();
//                    String posicion2=Reg[2].toString();
//                    Integer posicion3=Integer.parseInt(Reg[3].toString());
//                    GrabarDatos(new RelacionesformatounidadessubcuentasbalancesDTO(posicion0,posicion1,posicion2,posicion3));
//                    j++;
//                }
//                break;
                case 1026:
//                ((RelacionMonedasSubCuentasSBLocalHome)this.lookupSBBean("RelacionMonedasSubCuentasSBBean")).create().removeByObject(fechaCorte);
                    while (Registro.hasNext()) {
                        Object[] Reg = (Object[]) Registro.next();
                        Integer IDFORMATO = Integer.parseInt(Reg[0].toString());
                        String UNIDADDECAPTURA = Reg[1].toString();
                        String SUBCUENTA = Reg[2].toString();
                        Integer IDPRODUCTO = Integer.parseInt(Reg[3].toString());
                        this.EliminarDatos("Relacionsubcuentasproductos", fechaCorte);
                        GrabarDatos(new RelacionsubcuentasproductosDTO(fechaCorte, IDFORMATO, UNIDADDECAPTURA, SUBCUENTA, IDPRODUCTO));
                    }
                    break;
            }
            System.out.println("Se guardaron " + Datos.size() + " Registros");
        } catch (NumberFormatException e) {
            throw new Exception("No se pudo convertir a numero uno de los campo : " + e,e);
        } catch (IndexOutOfBoundsException e) {
            throw new Exception("Se esperaban mas columnas: " + e,e);
        } catch (NullPointerException e) {
            throw new Exception("Un campo de los que se esperaba llego null: " + e,e);
        } catch (CreateException e) {
            throw new Exception("Error grave : " + e,e);
        }
    }

    public Connection getConexion(String datasource) throws NamingException, SQLException {
        Context ctx = new InitialContext();
        DataSource ds_ = (DataSource) ctx.lookup("java:/" + datasource);
        return ds_.getConnection();
    }

    private Timestamp getFecha(String fecha) throws Exception {
        fecha = fecha.substring(0, 10);
        fecha = fecha.trim();
        String FECHA[] = new String[3];
        try {
            StringTokenizer fechaToken = null;
            if (fecha.contains("-")) {
                fechaToken = new StringTokenizer(fecha, "-");
            } else if (fecha.contains("/")) {
                fechaToken = new StringTokenizer(fecha, "/");
            }

            FECHA[0] = (String) fechaToken.nextElement();
            FECHA[1] = (String) fechaToken.nextElement();
            FECHA[2] = (String) fechaToken.nextElement().toString().substring(0, 4);
        } catch (java.lang.StringIndexOutOfBoundsException e) {
            StringTokenizer fechaToken = null;
            if (fecha.contains("-")) {
                fechaToken = new StringTokenizer(fecha, "-");
            } else if (fecha.contains("/")) {
                fechaToken = new StringTokenizer(fecha, "/");
            }

            FECHA[2] = (String) fechaToken.nextElement().toString().substring(0, 4);
            FECHA[1] = (String) fechaToken.nextElement();
            FECHA[0] = (String) fechaToken.nextElement();
        }

        return (new Timestamp(new Date(FECHA[1] + "/" + FECHA[0] + "/" + FECHA[2]).getTime()));
    }

    private String getFecha(Date fechaCorte, Date fechaInicial) {
        int DIA = Calendar.DAY_OF_MONTH;
        int MES = Calendar.MONTH;
        int ANNO = Calendar.YEAR;
        int numDias = -1;
        Calendar MyFecha = Calendar.getInstance();
        Calendar fechaDB = Calendar.getInstance();
        Calendar fechaDigitada = Calendar.getInstance();

        fechaDigitada.setTime((Date) fechaCorte.clone());
        fechaDB.setTime(fechaInicial);

        if (numDias != -1) {
            int anno = numDias / 360;
            int mes = (numDias % 360) / 30;
            int dias = (numDias % 360);
            if (dias > 30) {
                dias = dias - (mes * 30);
            }
            fechaDigitada.set(ANNO, fechaDigitada.get(ANNO) - anno);
            fechaDigitada.set(MES, fechaDigitada.get(MES) - mes);
            fechaDigitada.set(DIA, fechaDigitada.get(DIA) - dias);
            System.out.println(fechaDigitada.get(ANNO) + "-" + fechaDigitada.get(MES) + "-" + fechaDigitada.get(DIA));//fecha:Thu Feb 09 00:00:00 COT 2006
            System.out.println("SALE:" + fechaDigitada);
            return String.valueOf(fechaDigitada.get(ANNO) + "-" + fechaDigitada.get(MES) + "-" + fechaDigitada.get(DIA));
        } else {
            return String.valueOf(fechaDB.get(ANNO) + "-" + (fechaDB.get(MES) + 1) + "-" + fechaDB.get(DIA));
        }
    }
    ValoresMonedasSBLocal valoresMonedasSBLocal = null;

    private void GrabarDatos(ValoresmonedasDTO valoresmonedasDTO) throws CreateException, Exception {
        if (valoresMonedasSBLocal == null) {
            valoresMonedasSBLocal = ((ValoresMonedasSBLocalHome) this.lookupSBBean("ValoresMonedasSBBean")).create();
        }
        valoresMonedasSBLocal.createNewObject(valoresmonedasDTO);
    }
    TasaaSBLocal tasaaSBLocal = null;

    private void GrabarDatos(TasasDTO tasasDTO) throws CreateException, Exception {
        if (tasaaSBLocal == null) {
            tasaaSBLocal = ((TasaaSBLocalHome) this.lookupSBBean("TasaaSBBean")).create();
        }
        tasaaSBLocal.createNewObject(tasasDTO);
    }
    TasasValoresSBLocal tasasValoresSBLocal = null;

    private void GrabarDatos(TasasvaloresDTO tasasvaloresDTO) throws CreateException, Exception {
        if (tasasValoresSBLocal == null) {
            tasasValoresSBLocal = ((TasasValoresSBLocalHome) this.lookupSBBean("TasasValoresSBBean")).create();
        }
        tasasValoresSBLocal.createNewObject(tasasvaloresDTO);
    }
    EmpresasUnidadesNegociosSBLocal empresasUnidadesNegociosSBLocal = null;

    private void GrabarDatos(EmpresasUnidadesnegociosDTO empresasUnidadesnegociosDTO) throws CreateException, Exception {
        if (empresasUnidadesNegociosSBLocal == null) {
            empresasUnidadesNegociosSBLocal = ((EmpresasUnidadesNegociosSBLocalHome) this.lookupSBBean("EmpresasUnidadesNegociosSBBean")).create();
        }
        empresasUnidadesNegociosSBLocal.createNewObject(empresasUnidadesnegociosDTO);
    }
    LibrosCuentasProductosSBLocal librosCuentasProductosSBLocal = null;

    private void GrabarDatos(LibrosCuentasProductosDTO librosCuentasProductosDTO) throws CreateException, Exception {
        if (librosCuentasProductosSBLocal == null) {
            librosCuentasProductosSBLocal = ((LibrosCuentasProductosSBLocalHome) this.lookupSBBean("LibrosCuentasProductosSBBean")).create();
        }
        librosCuentasProductosSBLocal.createNewObject(librosCuentasProductosDTO);
    }
    EmisoresSBLocal emisoresSBLocal = null;

    private void GrabarDatos(EmisoresDTO emisoresDTO) throws CreateException, Exception {
        if (emisoresSBLocal == null) {
            emisoresSBLocal = ((EmisoresSBLocalHome) this.lookupSBBean("EmisoresSBBean")).create();
        }
        emisoresSBLocal.createNewObjet(emisoresDTO);
    }
    AccionesSBLocal accionesSBLocal = null;

    private void GrabarDatos(AccionesDTO accionesDTO) throws CreateException, Exception {
        if (accionesSBLocal == null) {
            accionesSBLocal = ((AccionesSBLocalHome) this.lookupSBBean("AccionesSBBean")).create();
        }
        accionesSBLocal.createNewObjet(accionesDTO);
    }
    AccionesPosicionesSBLocal accionesPosicionesSBLocal = null;

    private void GrabarDatos(AccionesposicionesDTO accionesposicionesDTO) throws CreateException, Exception {
        if (accionesPosicionesSBLocal == null) {
            accionesPosicionesSBLocal = ((AccionesPosicionesSBLocalHome) this.lookupSBBean("AccionesPosicionesBBean")).create();
        }
        accionesPosicionesSBLocal.createNewObject(accionesposicionesDTO);
    }
    AccionesValoresSBLocal accionesValoresSBLocal = null;

    private void GrabarDatos(AccionesvaloresDTO accionesvaloresDTO) throws CreateException, Exception {
        if (accionesValoresSBLocal == null) {
            accionesValoresSBLocal = ((AccionesValoresSBLocalHome) this.lookupSBBean("AccionesValoresSBBean")).create();
        }
        accionesValoresSBLocal.createNewObject(accionesvaloresDTO);
    }
    AccionesFlujosSBLocal accionesFlujosSBLocal = null;

    private void GrabarDatos(AccionesflujosDTO accionesflujosDTO) throws CreateException, Exception {
        if (accionesFlujosSBLocal == null) {
            accionesFlujosSBLocal = ((AccionesFlujosSBLocalHome) this.lookupSBBean("AccionesFlujosSBBean")).create();
        }
        accionesFlujosSBLocal.createNewObject(accionesflujosDTO);
    }
    AccionesPosicionesFlujosSBLocal accionesPosicionesFlujosSB = null;

    private void GrabarDatos(AccionesposicionesflujosDTO accionesposicionesflujosDTO) throws CreateException, Exception {
        if (accionesPosicionesFlujosSB == null) {
            accionesPosicionesFlujosSB = ((AccionesPosicionesFlujosSBLocalHome) this.lookupSBBean("AccionesPosicionesFlujosSBBean")).create();
        }
        accionesPosicionesFlujosSB.createNewObject(accionesposicionesflujosDTO);
    }
    EspeciesSBLocal especiesSBLocal = null;

    private void GrabarDatos(EspeciesDTO especiesDTO) throws CreateException, Exception {
        if (especiesSBLocal == null) {
            especiesSBLocal = ((EspeciesSBLocalHome) this.lookupSBBean("EspeciesSBBean")).create();
        }
        especiesSBLocal.createNewObject(especiesDTO);
    }
    EspeciesPosicionesSBLocal especiesPosicionesSBLocal = null;

    private void GrabarDatos(EspeciesposicionesDTO especiesposicionesDTO) throws CreateException, Exception {
        if (especiesPosicionesSBLocal == null) {
            especiesPosicionesSBLocal = ((EspeciesPosicionesSBLocalHome) this.lookupSBBean("EspeciesPosicionesSBBean")).create();
        }
        especiesPosicionesSBLocal.createNewObject(especiesposicionesDTO);
    }
    EspeciesValoresSBLocal especiesValoresSBLocal = null;

    private void GrabarDatos(EspeciesvaloresDTO especiesvaloresDTO) throws CreateException, Exception {
        if (especiesValoresSBLocal == null) {
            especiesValoresSBLocal = ((EspeciesValoresSBLocalHome) this.lookupSBBean("EspeciesValoresSBBean")).create();
        }
        especiesValoresSBLocal.createNewObject(especiesvaloresDTO);
    }
    EspeciesFlujosLocal especiesFlujosLocal = null;

    private void GrabarDatos(EspeciesflujosDTO especiesflujosDTO) throws CreateException, Exception {
        if (especiesFlujosLocal == null) {
            especiesFlujosLocal = ((EspeciesFlujosLocalHome) this.lookupSBBean("EspeciesFlujosSBBean")).create();
        }
        especiesFlujosLocal.createNewObject(especiesflujosDTO);
    }
    EspeciesTasasPagoLocal especiesTasasPagoLocal = null;

    private void GrabarDatos(EspeciestasaspagoDTO especiestasaspagoDTO) throws CreateException, Exception {
        if (especiesTasasPagoLocal == null) {
            especiesTasasPagoLocal = ((EspeciesTasasPagoLocalHome) this.lookupSBBean("EspeciesTasasPagoSBBean")).create();
        }
        especiesTasasPagoLocal.createNewObject(especiestasaspagoDTO);
    }
    EspeciesPosicionesFlujosLocal especiesPosicionesFlujosLocal = null;

    private void GrabarDatos(EspeciesposicionesflujosDTO especiesposicionesflujosDTO) throws CreateException, Exception {
        if (especiesPosicionesFlujosLocal == null) {
            especiesPosicionesFlujosLocal = ((EspeciesPosicionesFlujosLocalHome) this.lookupSBBean("EspeciesPosicionesFlujosSBBean")).create();
        }
        especiesPosicionesFlujosLocal.createNewObject(especiesposicionesflujosDTO);
    }
    ContratosSimplesSBLocal contratosSimplesSBLocal = null;

    private void GrabarDatos(ContratossimplesDTO contratossimplesDTO) throws CreateException, Exception {
        if (contratosSimplesSBLocal == null) {
            contratosSimplesSBLocal = ((ContratosSimplesSBLocalHome) this.lookupSBBean("ContratosSimplesSBBean")).create();
        }
        contratosSimplesSBLocal.createNewObject(contratossimplesDTO);
    }
    ContratosSimplesFlujosSBLocal contratosSimplesFlujosSBLocal = null;

    private void GrabarDatos(ContratossimplesflujosDTO contratossimplesflujosDTO) throws CreateException, Exception {
        if (contratosSimplesFlujosSBLocal == null) {
            contratosSimplesFlujosSBLocal = ((ContratosSimplesFlujosSBLocalHome) this.lookupSBBean("ContratosSimplesFlujosSBBean")).create();
        }
        contratosSimplesFlujosSBLocal.createNewObject(contratossimplesflujosDTO);
    }
    ContratosSimplesTasaPagoSBLocal contratosSimplesTasaPagoSBLocal = null;

    private void GrabarDatos(ContratossimplestasaspagoDTO contratossimplestasaspagoDTO) throws CreateException, Exception {
        if (contratosSimplesTasaPagoSBLocal == null) {
            contratosSimplesTasaPagoSBLocal = ((ContratosSimplesTasaPagoSBLocalHome) this.lookupSBBean("ContratosSimplesTasaPagoSBBean")).create();
        }
        contratosSimplesTasaPagoSBLocal.createNewObject(contratossimplestasaspagoDTO);
    }
    AdicionalesContratosLocal adicionalesContratosLocal = null;

    private void GrabarDatos(AdicionalescontratosDTO adicionalescontratosDTO) throws CreateException, Exception {
        if (adicionalesContratosLocal == null) {
            adicionalesContratosLocal = ((AdicionalesContratosLocalHome) this.lookupSBBean("AdicionalesContratosSBBean")).create();
        }
        adicionalesContratosLocal.createNewObject(adicionalescontratosDTO);
    }
    RelacionEspeciesSubcuentasSBLocal relacionEspeciesSubcuentasSBLocal = null;

    private void GrabarDatos(RelacionespeciessubcuentasDTO relacionespeciessubcuentasDTO) throws CreateException, Exception {
        if (relacionEspeciesSubcuentasSBLocal == null) {
            relacionEspeciesSubcuentasSBLocal = ((RelacionEspeciesSubcuentasSBLocalHome) this.lookupSBBean("RelacionEspeciesSubcuentasSBBean")).create();
        }

        relacionEspeciesSubcuentasSBLocal.createNewObject(relacionespeciessubcuentasDTO);
    }
    RelacionMonedasSubCuentasSBLocal relacionMonedasSubCuentasSBLocal = null;

    private void GrabarDatos(RelacionmonedassubcuentasDTO relacionmonedassubcuentasDTO) throws CreateException, Exception {
        if (relacionMonedasSubCuentasSBLocal == null) {
            relacionMonedasSubCuentasSBLocal = ((RelacionMonedasSubCuentasSBLocalHome) this.lookupSBBean("RelacionMonedasSubCuentasSBBean")).create();
        }

        relacionMonedasSubCuentasSBLocal.createNewObject(relacionmonedassubcuentasDTO);
    }
    RelacionsubcuentasproductosSBLocal relacionsubcuentasproductosSBLocal = null;

    private void GrabarDatos(RelacionsubcuentasproductosDTO relacionsubcuentasproductosDTO) throws CreateException, Exception {
        if (relacionsubcuentasproductosSBLocal == null) {
            relacionsubcuentasproductosSBLocal = ((RelacionsubcuentasproductosSBLocalHome) this.lookupSBBean("RelacionsubcuentasproductosSBBean")).create();
        }

        relacionsubcuentasproductosSBLocal.createNewObject(relacionsubcuentasproductosDTO);
    }

//    RelacionaccsubcuentasproductosSBLocal relacionsubcuentasproductosSBLocal=null;
//    private void GrabarDatos(RelacionsubcuentasproductosDTO relacionsubcuentasproductosDTO) throws CreateException, Exception {
//        if(relacionsubcuentasproductosSBLocal==null)
//            relacionsubcuentasproductosSBLocal=((RelacionsubcuentasproductosSBLocalHome)this.lookupSBBean("RelacionsubcuentasproductosSBBean")).create();
//
//        relacionsubcuentasproductosSBLocal.createNewObject(relacionsubcuentasproductosDTO);
//    }
    /**
     *
     * Example JNDI: TasaaSBBean
     * Example Casting ((ig.ejb.metrica.da.session.TasaaSBLocalHome)lookupSBBean(String JNDI))
     */
    private EJBLocalHome lookupSBBean(String JNDI) {
        try {
            javax.naming.Context c = new javax.naming.InitialContext();
            return (EJBLocalHome) c.lookup("java:comp/env/ejb/" + JNDI.trim());
        } catch (javax.naming.NamingException ne) {
            try {
                javax.naming.Context c = new javax.naming.InitialContext();
                return (EJBLocalHome) c.lookup(JNDI.trim());
            } catch (javax.naming.NamingException ne1) {
                java.util.logging.Logger.getLogger(getClass().getName()).log(java.util.logging.Level.SEVERE, "exception caught", ne1);
                throw new RuntimeException(ne);
            }
        }
    }

    private String getQUERY(String QUERY, boolean b) {
        String sinPeso = "";
        String sinArroba = "";
        String _QUERY = "";
        StringTokenizer tokenPeso = new StringTokenizer(QUERY, "$");
        boolean primero = true;
        while (tokenPeso.hasMoreTokens()) {
            if (!primero) {
                sinPeso = sinPeso + "_";
            } else {
                primero = false;
            }
            String TEMP = tokenPeso.nextToken().toString();
            for (int i = 0; i < TEMP.getBytes().length; i++) {
                if (!TEMP.substring(i, i + 1).equals("{") && !TEMP.substring(i, i + 1).equals("}")) {
                    sinPeso = sinPeso + TEMP.substring(i, i + 1);
                }
            }
        }
        QUERY = sinPeso;
        StringTokenizer tokenArroba = new StringTokenizer(QUERY, "@");
        primero = true;
        while (tokenArroba.hasMoreTokens()) {
            if (!primero) {
                sinArroba = sinArroba + "-";
            } else {
                primero = false;
            }
            String TEMP = tokenArroba.nextToken().toString();
            for (int i = 0; i < TEMP.getBytes().length; i++) {
                if (!TEMP.substring(i, i + 1).equals("{") && !TEMP.substring(i, i + 1).equals("}")) {
                    sinArroba = sinArroba + TEMP.substring(i, i + 1);
                }
            }
        }
        _QUERY = sinArroba;
        if (b) {
            return _QUERY.replaceAll("_FECHA_INICIAL", "?").replaceAll("_FECHA_CORTE", "?");
        } else {
            return _QUERY;
        }
    }

    @Override
    public void limpiarParametros() throws Exception, RemoteException {
        HTablasProcesadas = new Hashtable();
    }

    public void guardarGrupo(GrupoorigendatoDTO grupoorigendatoDTO, List<Long> idsOrigenesDatos) throws Exception, RemoteException {
        GrupoorigendatoDAO grupoorigendatoDAO = new GrupoorigendatoDAO();
        RelaciongrupoodatoDAO relaciongrupoodatoDAO = new RelaciongrupoodatoDAO();
        Integer ID = null;//grupoorigendatoDTO.getPk() == null ? grupoorigendatoDAO.create(grupoorigendatoDTO) : grupoorigendatoDAO.update(grupoorigendatoDTO);
        if(grupoorigendatoDTO.getPk() == null){
            ID = grupoorigendatoDAO.create(grupoorigendatoDTO);
        }else{
            ID = grupoorigendatoDTO.getPk();
            grupoorigendatoDAO.update(grupoorigendatoDTO);
        }
        for (Long long1 : idsOrigenesDatos) {
            RelaciongrupoodatoDTO relaciongrupoodatoDTO = new RelaciongrupoodatoDTO( long1.intValue(), ID);
            relaciongrupoodatoDAO.create(relaciongrupoodatoDTO);
        }
    }

    public void eliminarGrupo(GrupoorigendatoDTO grupoorigendatoDTO) throws Exception, RemoteException {
        if(grupoorigendatoDTO.getPk()!=null){
            eliminarRelacion(grupoorigendatoDTO);
            GrupoorigendatoDAO grupoorigendatoDAO = new GrupoorigendatoDAO();
            grupoorigendatoDAO.delete(grupoorigendatoDTO);
        }
    }

    public void eliminarRelacion(GrupoorigendatoDTO grupoorigendatoDTO) throws Exception, RemoteException {
        RelaciongrupoodatoDAO relaciongrupoodatoDAO = new RelaciongrupoodatoDAO();
        relaciongrupoodatoDAO.deleteByIdGrupo(grupoorigendatoDTO.getPk());
    }

    
    public List<GrupoorigendatoDTO> buscarTodosLosGrupos()throws Exception, RemoteException {
        return new GrupoorigendatoDAO().findAll();
    }
    
    public List<RelaciongrupoodatoDTO> buscarRelacionesPorGrupo(Integer idGrupo)throws Exception, RemoteException {
        return new RelaciongrupoodatoDAO().findByIdgrupoodato(idGrupo);
    }    
}
